// 引入必要的命名空间
using Microsoft.AspNetCore.Mvc; // 提供ASP.NET Core MVC功能，如控制器和HTTP响应
using UniversalAdmin.Application.DTOs; // 引入数据传输对象定义，用于API与服务的交互
using UniversalAdmin.Application.Services; // 引入服务层接口和实现，用于业务逻辑处理


// 定义API控制器的命名空间
namespace UniversalAdmin.Api.Controllers;

// 标记为API控制器，并定义路由
[ApiController] // 标识该类为API控制器，自动处理模型验证和HTTP响应
[Route("api/v1/[controller]")] // 定义路由模板，[controller]会被替换为控制器名称（User）
public class UserController : ControllerBase // 继承自ControllerBase，提供HTTP响应功能
{
    // 用户服务接口实例，通过依赖注入获取
    private readonly IUserService _userService;

    // 构造函数，注入IUserService依赖
    public UserController(IUserService userService)
    {
        _userService = userService; // 初始化用户服务，确保后续方法可用
    }

    // 分页获取用户列表
    [HttpGet]
    public async Task<IActionResult> GetUsers([FromQuery] int page = 1, [FromQuery] int pageSize = 10)
    {
        var result = await _userService.GetUsersAsync(page, pageSize);
        return Ok(result);
    }
    /// <summary>
    /// 根据用户ID获取用户信息
    /// </summary>
    /// <param name="id">用户ID</param>
    /// <returns>用户信息</returns>
    [HttpGet("{id}")] // 定义HTTP GET方法，路由参数为id
    public async Task<IActionResult> GetUserById(Guid id)
    {
        // 调用用户服务获取用户信息
        var user = await _userService.GetUserByIdAsync(id);
        // 如果用户不存在，返回404；否则返回200和用户数据
        return user == null ? NotFound(new { message = "用户不存在" }) : Ok(user);
    }

    /// <summary>
    /// 根据关键字搜索用户
    /// </summary>
    /// <param name="keyword">搜索关键字</param>
    /// <returns>匹配的用户列表</returns>
    [HttpGet("search")] // 定义HTTP GET方法，路由为search
    public async Task<IActionResult> SearchUsers(string keyword)
    {
        // 调用用户服务搜索用户
        var user = await _userService.SearchUsersAsync(keyword);
        // 返回200和搜索结果
        return Ok(user);
    }

    /// <summary>
    /// 更新用户信息
    /// </summary>
    /// <param name="id">用户ID</param>
    /// <param name="dto">更新用户数据的传输对象</param>
    /// <returns>更新结果</returns>
    [HttpPut("{id}")] // 定义HTTP PUT方法，路由参数为id
    public async Task<IActionResult> UpdateUser(Guid id, [FromBody] UpdateUserDto dto)
    {
        // 调用用户服务更新用户信息
        var update = await _userService.UpdateUserAsync(id, dto);
        // 如果用户不存在，返回404；否则返回200和更新成功消息
        return update == null ? NotFound(new { message = "用户不存在" }) : Ok(new { message = "更新成功", Data = update });
    }

    /// <summary>
    /// 创建新用户
    /// </summary>
    /// <param name="dto">创建用户数据的传输对象</param>
    /// <returns>创建结果</returns>
    [HttpPost] // 定义HTTP POST方法
    public async Task<IActionResult> CreateUser([FromBody] CreateUserDto dto)
    {
        try
        {
            // 调用用户服务创建用户
            var user = await _userService.CreateUserAsync(dto);
            // 返回201 Created响应，包含新用户的URI和用户信息
            return CreatedAtAction(nameof(GetUserById), new { id = user.Id }, user);
        }
        catch (Exception ex)
        {
            // 如果发生异常，返回400 Bad Request响应，包含错误信息
            return BadRequest(new { message = ex.Message });
        }
    }

    /// <summary>
    /// 删除用户
    /// </summary>
    /// <param name="id">用户ID</param>
    /// <returns>删除结果</returns>
    [HttpDelete("{id}")] // 定义HTTP DELETE方法，路由参数为id
    public async Task<IActionResult> DeleteUser(Guid id)
    {
        try
        {
            // 调用用户服务删除用户
            var success = await _userService.DeleteUserAsync(id);
            // 如果删除成功，返回204 No Content响应；否则返回404 Not Found响应
            return success ? NoContent() : NotFound(new { message = "用户不存在" });
        }
        catch (Exception ex)
        {
            // 如果发生异常，返回400 Bad Request响应，包含错误信息
            return BadRequest(new { message = ex.Message });
        }
    }

    /// <summary>
    /// 获取用户的角色列表
    /// </summary>
    /// <param name="userId">用户ID</param>
    /// <returns>用户的角色列表</returns>
    [HttpGet("{userId}/roles")]
    public async Task<IActionResult> GetUserRoles(Guid userId)
    {
        try
        {
            var roles = await _userService.GetUserRolesAsync(userId);
            return Ok(roles);
        }
        catch (Exception ex)
        {
            return BadRequest(new { message = ex.Message });
        }
    }

    /// <summary>
    /// 为用户分配角色
    /// </summary>
    /// <param name="userId">用户ID</param>
    /// <param name="request">角色分配请求</param>
    /// <returns>分配结果</returns>
    [HttpPost("{userId}/roles")]
    public async Task<IActionResult> AssignRolesToUser(Guid userId, [FromBody] AssignRolesRequest request)
    {
        try
        {
            await _userService.AssignRolesToUserAsync(userId, request.RoleIds);
            return Ok(new { message = "角色分配成功" });
        }
        catch (Exception ex)
        {
            return BadRequest(new { message = ex.Message });
        }
    }

    /// <summary>
    /// 获取用户的所有权限
    /// </summary>
    /// <param name="userId">用户ID</param>
    /// <returns>用户的权限列表</returns>
    [HttpGet("{userId}/permissions")]
    public async Task<IActionResult> GetUserPermissions(Guid userId)
    {
        try
        {
            var permissions = await _userService.GetUserPermissionsAsync(userId);
            return Ok(permissions);
        }
        catch (Exception ex)
        {
            return BadRequest(new { message = ex.Message });
        }
    }
}

// 角色分配请求DTO
public record AssignRolesRequest(List<Guid> RoleIds);
